%% Einführung in die Programmierung mit Python
%% Copyright © 2013, Dominik George <nik@naturalnet.de>
%% Licensed under Create Commons BY-SA 3.0 DE
%%-
%% Code samples (i.e., content of lstlisting environments) are published
%% under The MirOS Licence, as far as they are protectable.
%%-
%% OpenRheinRuhr is granted permission to relicense this work under any
%% compatible OSI-approved licence.

\documentclass{beamer}

\usepackage[ngerman]{babel}
\usepackage[utf8x]{inputenc}
\usepackage{graphicx}

\usepackage{listings}
\usepackage{color}
\usepackage{textcomp}
\definecolor{listinggray}{gray}{0.9}
\definecolor{lbcolor}{rgb}{0.9,0.9,0.9}
\lstset{
	backgroundcolor=\color{lbcolor},
	tabsize=4,
	rulecolor=,
	language=matlab,
        basicstyle=\scriptsize,
        upquote=true,
        aboveskip={1.5\baselineskip},
        columns=fixed,
        showstringspaces=false,
        extendedchars=true,
        breaklines=true,
        prebreak = \raisebox{0ex}[0ex][0ex]{\ensuremath{\hookleftarrow}},
        frame=single,
        showtabs=false,
        showspaces=false,
        showstringspaces=false,
        identifierstyle=\ttfamily,
        keywordstyle=\color[rgb]{0,0,1},
        commentstyle=\color[rgb]{0.133,0.545,0.133},
        stringstyle=\color[rgb]{0.627,0.126,0.941},
}
\lstset{literate=%
{Ö}{{\"O}}1
{Ä}{{\"A}}1
{Ü}{{\"U}}1
{ß}{{\ss}}2
{ü}{{\"u}}1
{ä}{{\"a}}1
{ö}{{\"o}}1
{_}{{\_}}1
}

\usetheme{Ilmenau}

\setbeamercovered{transparent}
\beamertemplatenavigationsymbolsempty
\setbeamertemplate{footline}[frame number]

\title{Einführung in die Programmierung mit Python}
\subtitle{Kurze, aber umfassende Einführung in die Programmiersprache Python}
\author{Dominik George}
\institute{OpenRheinRuhr 2013, Oberhausen}
\date{\today}
\subject{Python}
\keywords{Python,Programmierung}
\titlegraphic{\includegraphics{python-logo}}

\begin{document}
 \section{Einleitung}
 \subsection{Begrüßung}

 \begin{frame}
  \titlepage
 \end{frame}

 \begin{frame}
  \begin{columns}
   \column{.5\textwidth}
   \begin{itemize}
    \item{Dominik George (Nik, Natureshadow)}
    \item{23 Jahre alt}
    \item{Student (Anglistik. Informatik, Elektrotechnik)}
    \item{Informatik-Projektlehrer an der Sekundarschule}
    \item{Organisation des Kinder- und Jugendprogramms der FrOSCon}
    \item{Routinemäßiger Konferenz-Besucher und -Mitmacher}
   \end{itemize}
   \column{.5\textwidth}
   \includegraphics[width=.95\textwidth]{foto}
  \end{columns}
 \end{frame}

 \begin{frame}
  \frametitle{Inhalt}
  \tableofcontents
 \end{frame}

 \subsection{Was ist Python?}

 \begin{frame}[<+->]
  \frametitle{Was ist Python?}

  \begin{itemize}
   \item{Eine Programmiersprache}
   \item{Frei und offen}
   \item{Einfach zu lernen}
   \item{Lesbar}
   \item{Erweiterbar}
   \item{Umfassend}
  \end{itemize}
 \end{frame}

 \begin{frame}[<+->]
  \frametitle{Ideen, die Python abheben}

  \begin{itemize}
   \item{Code soll schön sein}
   \item{Einfaches soll einfach sein}
   \item{Lesbarkeit zählt}
   \item{Regeln sollen einhaltbar sein}
   \item{Der richtige Weg soll offensichtlich sein}
   \item{Holländer sind merkwürdig ;-)}
  \end{itemize}
 \end{frame}

 \begin{frame}
  \frametitle{The Zen of Python, by Tim Peters}

  \begin{itemize}
   \item{Beautiful is better than ugly.}
   \item{Explicit is better than implicit.}
   \item{Simple is better than complex.}
   \item{Complex is better than complicated.}
   \item{Flat is better than nested.}
   \item{Sparse is better than dense.}
   \item{Readability counts.}
   \item{Special cases aren't special enough to break the rules.}
   \item{Although practicality beats purity.}
   \item{Errors should never pass silently.}
  \end{itemize}
 \end{frame}

 \begin{frame}
  \frametitle{The Zen of Python, by Tim Peters (Teil 2)}

  \begin{itemize}
   \item{Unless explicitly silenced.}
   \item{In the face of ambiguity, refuse the temptation to guess.}
   \item{There should be one-- and preferably only one --obvious way to do it.}
   \item{Although that way may not be obvious at first unless you're Dutch.}
   \item{Now is better than never.}
   \item{Although never is often better than *right* now.}
   \item{If the implementation is hard to explain, it's a bad idea.}
   \item{If the implementation is easy to explain, it may be a good idea.}
   \item{Namespaces are one honking great idea -- let's do more of those!}
  \end{itemize}
 \end{frame}

 \begin{frame}
  \frametitle{Python macht Spaß}

  \begin{center}
   \includegraphics[width=\textwidth,height=0.8\textheight,keepaspectratio]{antigravity}
  \end{center}
 \end{frame}

 \begin{frame}[fragile]
  \frametitle{Code soll schön sein}

  \begin{lstlisting}[language=python]
for i in range(0, 10):
    print(i)
  \end{lstlisting}

  vs.

  \begin{lstlisting}[language=c]
int i;
for (i = 0; i < 10; i++) printf("%d\n", i);
  \end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Einfaches soll einfach sein}

  \begin{lstlisting}[language=python]
   print("Hallo Welt!")
  \end{lstlisting}

  vs.

  \begin{lstlisting}[language=java]
public class HalloProgramm {
 public static void main(String[] args) {
  System.out.println("Hallo Welt!");
  System.exit(0);
 }
}
  \end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Lesbarkeit zählt}

  \begin{lstlisting}[language=python]
for quant in range(99, 0, -1):
   if quant > 1:
      print(quant, "bottles of beer on the wall,", quant, "bottles of beer.")
      suffix = str(quant - 1) + " bottle" + ("s" if quant > 2 else "") + " of beer on the wall."
   elif quant == 1:
      print("1 bottle of beer on the wall, 1 bottle of beer.")
      suffix = "no more beer on the wall!"
   print("Take one down, pass it around,", suffix)
  \end{lstlisting}

  vs.

  \begin{lstlisting}[language=perl]
sub b{$n=99-@_-$_||No;"$n bottle"."s"x!!--$n." of beer"};$w=" on the wall";
die map{b."$w,\n".b.",\nTake one down, pass it around,\n".b(0)."$w.\n\n"}0..98
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Holländer sind merkwürdig ;-)}

  \begin{lstlisting}[language=python]
>>> a = "abd"
>>> a[2]
'd'
>>> a[2] = "c"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
\end{lstlisting}

Wait... what ;)?
\end{frame}

 \subsection{Was wir für Python brauchen}

 \begin{frame}[<+->]
  \frametitle{Was wir für Python brauchen}

  \begin{itemize}
   \item{Einen Texteditor
    \begin{itemize}
     \item{Möglichst etwas brauchbarer als Microsoft® Notepad ;-)}
     \item{Empfehlung für die Linuxer/BSDler: jupp
      \begin{itemize}
       \item{Schnell}
       \item{Viele Features}
       \item{Einfach zu bedienen}
       \item{Gute Online-Hilfe (Strg+J)}
       \item{Syntax-Highlighting}
      \end{itemize}
     }
    \end{itemize}
   }
   \item{Python-Interpreter
    \begin{itemize}
     \item{Python 2.7 oder 3.3}
     \item{Interaktiv: bpython oder IDLE}
    \end{itemize}
   }
  \end{itemize}
 \end{frame}

 \section{Sprache}

 \subsection{Aufbau}

 \begin{frame}[fragile]
  \frametitle{Hallo Welt!}

  Ein einfaches, klassisches Hallo, Welt!-Programm in Python:

  \begin{lstlisting}[language=python]
#!/usr/bin/env python
# ~*~ coding: utf-8 ~*~

print("Hallo, Welt!")
exit(0)
  \end{lstlisting}
\end{frame} 

 \begin{frame}[fragile]
  \frametitle{Funktionsaufrufe}

  Funktionsaufrufe haben in Python immer - grundlegend - dieselbe Struktur:

  \begin{lstlisting}[language=python]
funktionsname(argument1, argument2, argument3, ...)
  \end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Statements (Anweisungen) und Blöcke}

  In Python wird meistens ein Statement pro Zeile geschrieben.

  \begin{lstlisting}
# Richtig
print("Hallo")
print("Welt")

# Meistens falsch
print("Hallo"); print("Welt")
  \end{lstlisting}

  Blöcke werden durch Einrückung markiert:

  \begin{lstlisting}[language=python]
def eggs():
    spam()
    bacon()
  \end{lstlisting}

  Wichtig: Immer die gleiche Einrückung verwenden.\\
  Empfehlung: 4 Leerzeichen (macht jupp automatisch richtig)
\end{frame}

 \begin{frame}[<+->]
  \frametitle{Variablen und Datentypen}

  \begin{itemize}
   \item{Variablen sind nicht typisiert ...}
   \item{... zeigen aber auf Daten mit einem bestimmten Datentyp!}
   \item{Datentypen (unvollständig):
    \begin{itemize}
     \item{str, bool, int, float, complex, list, tuple, dict}
    \end{itemize}
   }
   \item{Komplexere Typen (später mehr):
    \begin{itemize}
     \item{Objekte, Iteratoren, ...}
    \end{itemize}
   }
  \item{In Python ist alles "zuweisbar" (später mehr)}
  \end{itemize}
 \end{frame}

 \begin{frame}[<+->]
  \frametitle{Operatoren}

  \begin{itemize}
   \item{Arithmetische Operatoren (Berechnungen):
    \begin{itemize}
     \item{+, -, *, /, \%, **, //}
    \end{itemize}
   }
   \item{Zuweisungen:
    \begin{itemize}
     \item{=, +=, -=, *=, /=, \%=, **=, //=}
    \end{itemize}
   }
   \item{Vergleiche:
    \begin{itemize}
     \item{==, !=, >, <, >=, <=}
    \end{itemize}
   }
   \item{Listenoperatoren:
    \begin{itemize}
     \item{in, not in}
    \end{itemize}
   }
   \item{Logische Operatoren:
    \begin{itemize}
     \item{and, or, not}
    \end{itemize}
   }
  \end{itemize}
 \end{frame}

 \begin{frame}[fragile]
  \frametitle{Variablen, Datentypen und Operatoren (Beispiele)}

  \begin{lstlisting}[language=python]
a = "Hallo Welt!"
b = 5
c = 2.5
d = b / c
e = ["spam", "bacon", "eggs"]
f = {"name": "Monty Python",
     "favourite_food": "spam"}
\end{lstlisting}

  Das Aufzählen endloser Beispiele wäre etwas langweilig, im
  Zweifelsfall einfach mal ausprobieren!

\end{frame}

 \begin{frame}[fragile]
  \frametitle{Einfache Ein- und Ausgabe}

  Die Funktionen print() und input() ermöglichen einfache Ein- und Ausgabe:

  \begin{lstlisting}[language=python]
print("Hallo Welt!")
print(2)

mein_name = input("Wie heißt du? ")
print("Hallo, " + mein_name)
\end{lstlisting}

 Achtung: In Python 2.x heißt input noch raw\_input, pythonischer Hack siehe später!

\end{frame}

 \begin{frame}[<+->]
  \frametitle{Schleifen}

  \begin{itemize}
   \item{Es gibt beide klassischen Schleifen-Typen
    \begin{itemize}
     \item{while-Schleife
      \begin{itemize}
       \item{Code-Block so lange ausführen, bis eine Bedingung nicht mehr erfüllt ist.}
       \item{Kleine pythonische Besonderheit, dazu später mehr ;-).}
      \end{itemize}
     }
     \item{for-Schleife
      \begin{itemize}
       \item{Code-Block für jedes Element einer Menge einmal ausführen.}
       \item{Kleine pythonische Besonderheit mit Iteratoren ...}
      \end{itemize}
     }
    \end{itemize}
   }
  \end{itemize}
 \end{frame}

 \begin{frame}[fragile]
  \frametitle{Schleifen (Beispiele)}

  \begin{lstlisting}[language=python]
eingabe = ""
while eingabe != "exit":
    eingabe = input("prompt> ")
\end{lstlisting}

  \begin{lstlisting}[language=python]
for food in ["spam", "bacon", "eggs"]:
    print("I like %s!" % food)
\end{lstlisting}

  (Habt ihr die pythonische Besonderheit bemerkt ;-)? Später mehr!)
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Bedingungen (Beispiele)}

  Weil Python so schön einfach ist, vertiefen wir direkt einmal das
  Eingabe-Beispiel von vorhin ;-) ...

  \begin{lstlisting}[language=python]
eingabe = ""
while eingabe != "exit":
    eingabe = input("gimme food> ")
    if eingabe in ["eggs", "bacon", "ham"]:
        print("I like %s!" % eingabe)
    elif eingabe == "spam":
        print("Don't you have Python without the spam?")
    else:
        print("What the spam is %s?" % eingabe)
\end{lstlisting}

  (Haben Sie den Bug bemerkt ;-)?)
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Funktionen}

  Funktionen sind benannte Code-Blöcke mit einer Parameterliste und einem Rückgabewert.

  \begin{lstlisting}[language=python]
def double(a):
    return 2 * a

print(double(5))
\end{lstlisting}

  \begin{lstlisting}[language=python]
def count_to(n):
    i = 0
    while i <= n:
        print(n)

count_to(10)
\end{lstlisting}
\end{frame}

 \begin{frame}[<+->]
  \frametitle{Listen und Tuples}

  \begin{itemize}
   \item{Listen sind ein bisschen mächtiger als traditionelle Arrays.}
   \item{Listen beinhalten Einträge beliebiger Typen, auch gemischt.}
   \item{Listen kann man an beliebigen Stellen beliebig manipulieren.}
   \item{Tuples sind unveränderbare Listen.}
   \item{Allgemein heißen "Aufzählungstypen" iterables.}
  \end{itemize}
 \end{frame}

 \begin{frame}[fragile]
  \frametitle{Listen (Beispiele)}

  \begin{lstlisting}[language=python]
foods = ["spam", "bacon", "eggs"]
foods[0]   # "spam"
foods[2]   # "eggs"
foods[-1]  # "eggs" -- vom Ende!

foods.append("beans")
foods      # ["spam", "bacon", "eggs", "beans"]

foods.index("eggs")   # 2
del foods[1]          # ["spam", "eggs", "beans"]
len(foods)            # 3
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Strings}

  Strings können in Python nur mit speziellen String-Methoden verändert
  werden - Strings sind keine Zeichen-Arrays, wie in C!

  Aber: Strings sind "iterables" - d.h., lesend verhalten sie sich genau
  wie Listen!

  \begin{lstlisting}[language=python]
message = "I like spam!"
message[0]    # "I"
message[-1]   # "!"
message[7:11] # "spam"

message = message.replace("spam", "bacon")
message       # "I like bacon!"
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Dictionaries}

  Dictionaries sind prinzipiell Python's Art von assoziativen Arrays /
  Hashtables.

  \begin{lstlisting}[language=python]
steckbrief = {"vorname": "John", "nachname": "Doe"}
steckbrief["vorname"]     # "John"

steckbrief["alter"] = 42
steckbrief     # {"vorname": "John", "nachname": "Doe", "alter": 42}

for key in steckbrief:
    print(steckbrief[key])
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Umwandeln von Typen (Casts)}

  Manchmal ist es notwendig, ausdrücklich Typen umzuwandeln, auch wenn
  Python das meistens recht gut macht.

  \begin{lstlisting}[language=python]
food = "Spam"
list(food)     # ["S", "p", "a", "m"]

float(5)       # 5.0
str(42)        # "42" -- ganz wichtig, siehe unten ...

a = 12
print("Ich bin " + str(a) + " Jahre alt!")
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Klassen und Objekte}

  Klassen sind "Sammlungen" von Variablen (Attributen) und Funktionen
  (Methoden) unter einem Namen. Von ihnen kann man voneinander
  unabhängige Kopien (Instanzen) erzeugen.

  \begin{lstlisting}[language=python]
class Baum():
    def __init__(self, groesse):
        self.groesse = groesse

    def wachsen(self):
        self.groesse += 1

mein_baum = Baum(10)
mein_baum.wachsen()
mein_baum.groesse      # 11
\end{lstlisting}

  Der erste Parameter der Methoden (hier self genannt) bekommt immer
  automatisch eine Referenz auf die Instanz übergeben, in der die
  Methode aufgerufen wurde.
\end{frame}

 \subsection{Pythonische Besonderheiten}

 \begin{frame}[fragile]
  \frametitle{Einsetzen in Strings}

  In Python sollten Variablen nicht einfach durch Verketten, sondern
  durch Platzhalter in Strings eingesetzt werden.

  \begin{lstlisting}[language=python]
name = "John"
alter = 42

print("Mein Name ist %s; ich bin %i Jahre alt!" % (name, alter))
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{List comprehensions}

  List comprehensions sind eine Kurzschreibweise, um schnell Listen nach
  einem bestimmen Muster erzeugen zu können. Im Prinzip wird eine
  for-Schleife aufgerufen und mit jedem Wert dieselbe Operation
  ausgeführt.

  \begin{lstlisting}[language=python]
# Eine Reihe Zahlen, aber als String (direkter Cast)
zahlen = [str(x) for x in range(10)]
zahlen    # ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]

# Oder die Buchstaben von A-Z aus ihren ASCII-Werten
alpha = [chr(x= for x in range(65, 91)]
\end{lstlisting}
\end{frame}

 \begin{frame}[<+->]
  \frametitle{Iteratoren/Generatoren}

  Iteratoren sind eine Möglichkeit, eine Menge von Elementen zu
  generieren, ohne diese komplett vorberechnen zu müssen. Was sinnlos
  klingt, hat Performance-Gründe ...

  \begin{itemize}
   \item{Wenn ich eine Bibliothek entwickle, und dabei eine Menge erzeuge,
         weiß ich nicht unbedingt, wie viele Elemente davon der Benutzer braucht.}
   \item{for-Schleifen laufen "gleichmäßiger" - jedes Element wird zum
         Zeitpunkt der Benutzung erzeugt.}
   \item{Speicherverbrauch ist minimal - nur ein Element muss im Speicher
         gehalten werden.}
   \item{Prinzip ist einfach: Eine Funktion erzeugt einen Rückgabewert,
         und die Position im Code wird gespeichert. Beim nächsten Aufruf
         läuft die Funktion an dieser Stelle weiter.}
  \end{itemize}
 \end{frame}

 \begin{frame}[fragile]
  \frametitle{Iteratoren/Generatoren (Beispiel)}

  Wir berechnen die Fibonacci-Folge mit einem Generator.

  \begin{lstlisting}[language=python]
def fibonacci():
    a = 1
    b = 1
    while True:
        c = a + b
        a = b
        b = c
        yield c   # Hier wird angehalten!

a = fibonacci()
a.next()          # 2
a.next()          # 3
a.next()          # 5
a.next()          # 8

for f in fibonacci():
    print(f)
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Alles ist zuweisbar}

  Auch eine Funktion ist ein zuweisbares \"Objekt", das wir beliebig
  benennen, zurückgeben, ... können.

  \begin{lstlisting}[language=python]
def give_me_spam():
    def spam():
        print("I don't like spam!")

    return spam

food = spam     # Hier bekommen wir die Fnuktion spam zurückgegeben und speichern sie unter dem Namen food!
food()          # Und dieser Aufruf ist identisch zum Aufruf spam() in give_me_spam()
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Dynamische Argumentlisten und Keyword-Argumente}

  Eine Funktion kann eine beliebige, undefinierte Anzahl von Argumenten
  annehmen.

  \begin{lstlisting}[language=python]
def spam(*args):
    print(args)

spam(1, 2, 3)     # [1, 2, 3]
\end{lstlisting}

  Außerdem kann eine Funktion beliebige Argumente mit Namen annehmen.

  \begin{lstlisting}[language=python]
def eggs(**kwargs):
    print(kwargs)

eggs(good="bacon", bad="spam")    # {"good": "bacon", "bad": "spam"}
\end{lstlisting}
\end{frame}

 \begin{frame}[<+->]
  \frametitle{Dekoratoren}

  Dekoratoren sind eine einfache Möglichkeit, Funktionen zu
  manipulieren, ohne ihren Code zu verändern. Man kann sie aber auch
  kreativ missbrauchen ...

  \begin{itemize}
   \item{Dekoratoren sind Funktionen, die als Argument die zu dekorierende
         Funktion übergeben bekommen und dann eine andere Funktion
         zurückgeben.}
   \item{Die zu dekorierende Funktion wird dann durch die zurückgegebene
         Funktion ersetzt.}
   \item{Man kann auch dieselbe Funktion unverändert zurückgeben ...
         Sinn siehe später ;-).}
  \end{itemize}
 \end{frame}

 \begin{frame}[fragile]
  \frametitle{Dekoratoren (Beispiel)}

  Wir schreiben einen Dekorator, der den Rückgabewert der dekorierten
  Funktion verdoppelt.

  \begin{lstlisting}[language=python]
def double_me(orig):
    def doubled(*args, **kwargs):
        return 2 * orig(*args, **kwargs)
    return doubled

@double_me     # Ist dasselbe wie ein nachgestelltes sum = double_me(sum)!
def sum(a, b):
    return a + b

sum(2, 3)     # 10
\end{lstlisting}
\end{frame}

 \begin{frame}[<+->]
  \frametitle{Missbrauch von Dekoratoren}

  Dekoratoren kann man teilweise kreativ "missbrauchen".

  \begin{itemize}
   \item{Einfaches Callback/Plugin-System
    \begin{itemize}
     \item{Dekorator verwaltet eine Liste aller jemals übergebenen Funktionen}
     \item{Dekorator gibt die Funktion unverändert zurück
      \begin{itemize}
       \item{Dadurch erst einmal kein Effekt für die dekorierte Funktion ...}
       \item{... aber alle dekorierten Funktionen sind gespeichert ("registriert").}
      \end{itemize}
     }
     \item{Mit den gespeicherten Funktionen kann man dann gesammelt etwas tun}
    \end{itemize}
   }
  \end{itemize}
 \end{frame}

 \begin{frame}[fragile]
  \frametitle{Missbrauch von Dekoratoren (Beispiel)}

  \begin{lstlisting}[language=python]
callbacks = []
def callback(func):
    callbacks.append(func)   # Funktion speichern
    return func              # Unverändert zurückgeben

def run_callbacks():
    for func in callbacks:
        func()

@callback
def spam():
    print("Spam is great!")

@callback
def eggs():
    print("Eggs are neat!")

run_callbacks()
\end{lstlisting}
\end{frame}

 \begin{frame}[fragile]
  \frametitle{Pythonische Hacks}

  Dank der erwähnten Besonderheiten der Sprache und ihrer Dynamik sind
  Probleme oft durch pythonische Hacks zu lösen. Ein Beispiel, um die
  Umbenennung der raw\_input-Funktion zu input in Python 3 zu
  reparieren:

  \begin{lstlisting}[language=python]
# Coole Kids schreiben Code für Python 2 und 3 ;-)!
try:
    raw_input          # Das wirft einen Fehler in Python 3
except:                # Den Fehler fangen wir ab.
    raw_input = input  # Und zum Glück können wir ja alles zuweisen!

mein_name = raw_input("Name: ")
\end{lstlisting}
\end{frame}

 \section{Ende}

 \subsection{Where to go from here ...}

 \begin{frame}
  \frametitle{Die nächsten wichtigen pythonischen Konzepte}

  Wenn das Interesse an der Sprache gewachsen ist, sollten diese
  Konzepte unbedingt erforscht werden:

  \begin{itemize}
   \item{Module importieren, eigene Module schreiben, Namespaces}
   \item{Vererbung}
   \item{\_\_repr\_\_(self), \_\_str\_\_(self)}
   \item{Exception-Handling (try.. except..}
   \item{Exceptions erzeugen und werfen}
   \item{with-Statement}
  \end{itemize}
 \end{frame}

 \begin{frame}
  \frametitle{Meine Lieblingsbibliotheken}

  Kurze Liste meiner Lieblingsmodule für bestimmte Zwecke (kann sich
  täglich ändern ;-)):

  \begin{itemize}
   \item{Webanwendungen: Flask (\url{http://flask.pocoo.org})}
   \item{Spiele: PyGame (\url{http://www.pygame.org})}
  \end{itemize}
 \end{frame}

 \begin{frame}
  \frametitle{Literaturempfehlungen}

  Es gibt nicht viele gute Bücher für Einsteiger ...

  \begin{itemize}
   \item{Für große und kleine Kinder:
    \begin{itemize}
     \item{Hello World! - Programmieren für Kids und andere Anfänger (Warren D. Sande und Carter Sande), ISBM: 978-3446421448}
     \item{Python kinderleicht!: Einfach programmieren lernen - nicht nur für Kids (Jason Briggs), ISBN: 978-3864900228}
     \item{Dr. Nuts und der teuflische Nussinator: Ein Jump'n'Run-Spiel in 14 Tagen (Eike Tim Jesinghaus, Dominik George), in Arbeit ;-)}
    \end{itemize}
   }
   \item{\url{http://docs.python.org}}
   \item{Monty Python: Spam - \url{https://www.youtube.com/watch?v=anwy2MPT5RE}}
  \end{itemize}
 \end{frame}

 \subsection{Credits und Dank}

 \begin{frame}
  \frametitle{Credits / Attribution}

  \begin{itemize}
   \item{Für meine Begeisterung und Vertiefung der Programmiersprache Python sowie gelegentliche Erziehungshiebe:
    \begin{itemize}
     \item{Eike Tim "Creeparoo" Jesinghaus (12)}
    \end{itemize}
   }
   \item{Antigravity-Comic (Folie 8):
    \begin{itemize}
     \item{Randall Munroe, \url{http://xkcd.com/353/} (CC-BY-NC 2.5)}
    \end{itemize}
   }
  \end{itemize}
 \end{frame}

 \begin{frame}
  Vielen Dank für eure Teilnahme!

  Für weitere Fragen, Anregungen, etc.:

  Website: \url{http://www.dominik-george.de}\\
  E-Mail / Jabber: nik@naturalnet.de

  Lizenz der Folien: CC-BY-SA 3.0
 \end{frame}
\end{document}